﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
#include<vector>
#include<list>
using namespace std;

//// 实例演⽰三种继承关系下基类成员的各类型成员访问关系的变化
//class Person
//{
//public:
//	void Print()
//	{
//		cout << _age << endl;
//		cout << _name << endl;
//	}
//protected:
//	string _name= "李曹彭"; // 姓名
//private:
//	int _age=18; // 年龄
//};
////class Student : protected Person
////class Student : private Person
//class Student : public Person
//{
//public:
//
//protected:
//	int _stunum; // 学号
//};

//namespace lcp
//{
//	//template<class T>
//	//class vector
//	//{};
//	// stack和vector的关系，既符合is-a，也符合has-a
//	template<class T>
//	class stack : public std::vector<T>
//	{
//	public:
//		void push(const T& x)
//		{
//			// 基类是类模板时，需要指定⼀下类域，
//			// 否则编译报错:error C3861: “push_back”: 找不到标识符
//
//			// 因为stack<int>实例化时，也实例化vector<int>了
//			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
//			vector<T>::push_back(x);
//			//push_back(x);
//		}
//		void pop()
//		{
//			vector<T>::pop_back();
//		}
//		const T& top()
//		{
//			return vector<T>::back();
//		}
//		bool empty()
//		{
//			return vector<T>::empty();
//		}
//	};
//}
//
//template<class Container>
//void Print(const Container& c)
//{
//	//Container::const_iterator可能是静态成员变量，也有可能内嵌类型（内部类，typedef)
//	typename Container::const_iterator it = c.begin();
//	/*auto Container::const_iterator it = c.begin();*/
//	while (it != c.end())
//	{
//		cout << *it << " ";
//	}
//	cout << endl;
//}
//
//int main()
//{
//	vector<int> v1 = { 1,2,3,4 };
//	list<int> l1 = { 10,20,30,40 };
//	Print(v1);
//	Print(l1);
//
//
//
//	lcp::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//	return 0;
//}


//class Person
//{
//protected:
//	string _name; // 姓名
//	string _sex; // 性别
//public:
//	int _age=18; // 年龄
//};
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//
//
//int main()
//{
//	Student sobj;
//	//复制兼容转换，特殊处理
//	// 
//	// 1.派⽣类对象可以赋值给基类的指针/引⽤
//	//切割/切片
//	Person* pp = &sobj;
//	Person& rp = sobj;
//	rp._age++;
//
//	// ⽣类对象可以赋值给基类的对象是通过调⽤后⾯会讲解的基类的拷⻉构造完成的
//	Person pobj = sobj;
//	//2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
//	sobj = pobj;
//
//	return 0;
//}


//// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆
//class Person
//{
//protected:
//	string _name = "李曹彭"; // 姓名
//	int _num = 111; // ⾝份证号
//};
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//		cout << " 身份证号:" << Person::_num << endl;
//		cout << " 学号:" << _num << endl;
//	}
//protected:
//	int _num = 999; // 学号
//};
//int main()
//{
//	Student s1;
//	s1.Print();
//	return 0;
//};


//////////////////////////////////////////////////////////////////////////////////
//不写   默认生成
//默认生成的行为是什么？是否满足需求
//默认生成的不符合需求时，需要自己写

//class Person
//{
//public:
//	Person(const char* name = "peter")
//		: _name(name)
//	{
//		cout << "Person()" << endl;
//	}
//Person(const Person& p)
//	: _name(p._name)
//{
//	cout << "Person(const Person& p)" << endl;
//}
//Person& operator=(const Person& p)
//{
//	cout << "Person operator=(const Person& p)" << endl;
//	if (this != &p)
//		_name = p._name;
//	return *this;
//}
//~Person()
//{
//	cout << "~Person()" << endl;
//}
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//public:
//	Student(const char* name, int num)
//		: Person(name)
//		, _num(num)
//	{
//		cout << "Student()" << endl;
//	}
//	Student(const Student& s)
//		: Person(s)
//		, _num(s._num)
//	{
//		cout << "Student(const Student& s)" << endl;
//	}
//	Student& operator = (const Student& s)
//	{
//		cout << "Student& operator= (const Student& s)" << endl;
//		if (this != &s)
//		{
//			// 构成隐藏，所以需要显⽰调⽤
//			Person::operator =(s);
//			_num = s._num;
//		}
//		return *this;
//	}
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//protected:
//	int _num; //学号
//};
//
//int main()
//{
//	Student s1();
//}

// 实例演⽰三种继承关系下基类成员的各类型成员访问关系的变化
//class Person
//{
//public:
//	void Print()
//	{
//		cout << _name << endl;
//		cout << _age << endl;
//	}
//protected:
//	string _name = "lcp"; // 姓名
//private:
//	int _age = 18; // 年龄
//};
//
//class Student : public Person
//{
//public:
//	void func()
//	{
//		//_age++;
//	}
//protected:
//	int _stunum; // 学号
//};
//
//int main()
//{
//	Student s;
//	s.Print();
//	return 0;
//}

//namespace lcp
//{
//	//template<class T>
//	//class vector
//	//{};
//	// stack和vector的关系，既符合is-a，也符合has-a
//	template<class T>
//	class stack : public vector<T>
//	{
//		public:
//		void push(const T& x)
//		{
//			// 基类是类模板时，需要指定⼀下类域，
//			// 否则编译报错:error C3861: “push_back”: 找不到标识符
//			// 因为stack<int>实例化时，也实例化vector<int>了
//			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
//			vector<T>::push_back(x);
//			//push_back(x);
//		} 
//		void pop()
//		{
//			vector<T>::pop_back();
//		} 
//		const T& top()
//		{
//			return vector<T>::back();
//		} 
//		bool empty()
//		{
//			return vector<T>::empty();
//		}
//	};
//} 
//template<class Container>
//void Print(const Container& c)
//{
//	typename Container::const_iterator it = c.begin();
//	while (it != c.end())
//	{
//		cout << *it << " ";
//		it++;
//	}
//	cout << endl;
//}
//int main()
//{
//
//	//vector<int> v1 = { 1,2,3,4 };
//	//list<int> l1 = { 10,20,30,40 };
//	//Print(v1);
//	//Print(l1);
//
//	//lcp::stack<int> st;
//	//st.push(1);
//	//st.push(2);
//	//st.push(3);
//	//while (!st.empty())
//	//{
//	//	cout << st.top() << " ";
//	//	st.pop();
//	//} 
//	return 0;
//}
//class Person
//{
//protected:
//	string _name; // 姓名
//	string _sex; // 性别
//public:
//	int _age=18; // 年龄
//};
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//int main()
//{
//	Student sobj;
//	// 1.派⽣类对象可以赋值给基类的指针/引⽤
//	Person* pp = &sobj;
//	Person& rp = sobj;
//	rp._age++;
//	pp->_age++;
//	return 0;
//}


//// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆
//class Person
//{
//protected:
//	string _name = "⼩李⼦"; // 姓名
//	int _num = 111; // ⾝份证号
//};
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//		cout << " ⾝份证号:" << Person::_num << endl;
//		cout << " 学号:" << _num << endl;
//	}
//protected:
//	int _num = 999; // 学号
//};
//int main()
//{
//	Student s1;
//	s1.Print();
//	return 0;
//}

//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//int main()
//{
//	B b;
//	b.fun(10);
//	b.A::fun();
//	return 0;
//}


/////////////////////////////////////////////////////////
//不写，编译器默认生成的行为是什么？
//默认生成的不符合需求，自己写，得怎么写？
//class Person
//{
//public:
//	Person(const char* name = "peter")
//		: _name(name)
//	{
//		cout << "Person()" << endl;
//	} 
//	Person(const Person& p)
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	} 
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//		return *this;
//	}
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//public :
//	Student(const char* name, int num,const char* address)
//		: Person(name)
//		, _num(num)
//		,_address(address)
//	{
//		cout << "Student()" << endl;
//	} 
//	Student(const Student& s)
//		: Person(s)//传过去会自动切---切片
//		, _num(s._num)
//		,_address(s._address)
//	{
//		cout << "Student(const Student& s)" << endl;
//	} 
//	Student& operator = (const Student& s)
//	{
//		cout << "Student& operator= (const Student& s)" << endl;
//		if (this != &s)
//		{
//			// 构成隐藏，所以需要显⽰调⽤
//			Person::operator =(s);
//			_num = s._num;
//			_address = s._address;
//		} 
//		return* this;
//	} 
//	~Student()
//	{
//		cout << "~Student()" << endl;    
//	}
//protected:
//	int _num; //学号
//	string _address;
//};
//int main()
//{
//	Student s1("cp", 18,"茌平");
//	Student s2(s1);
//
//	Student s3("小李", 19, "聊城");
//	s1 = s3;
//
//	return 0;
//}

//// C++11的⽅法
//class Base final
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//private:
//	// C++98的⽅法
//	/*Base()
//	{}*/
//};
//class Derive :public Base
//{
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}

class Person
{
public:
	string _name;
	static int _count;
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p;
	Student s;
	// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
	// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份
	cout << &p._name << endl;
	cout << &s._name << endl;
	// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
	// 说明派⽣类和基类共⽤同⼀份静态成员
	cout << &p._count << endl;
	cout << &s._count << endl;
	// 公有的情况下，⽗派⽣类指定类域都可以访问静态成员
	cout << &Person::_count << endl;
	cout << &Student::_count << endl;
	return 0;
}